package util;

import java.util.Random;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.text.StrBuilder;

import enums.Separator;

/**
 * 
 * String帮助类
 * 
 * @author: 唐竹
 * @date 创建时间：2011-6-7 下午04:33:56
 * @see {@link org.springframework.util.StringUtils}
 * 
 */
public class StringHelper extends org.springframework.util.StringUtils {

	/**
	 * The empty String <code>""</code>.
	 */
	public static final String EMPTY = "";

	/**
	 * 将首字母大写
	 * 
	 * @param str
	 * @return String 返回首字母大写后的字符串
	 */
	public static String capitalize(String str) {
		if (StringHelper.hasLength(str)) {
			StringBuffer wrod = new StringBuffer();

			str = wrod.append(str.substring(0, 1).toUpperCase()).append(str.substring(1)).toString();
		}
		return str;
	}

	/**
	 * 将首字母小写
	 * 
	 * @param str
	 * @return String 返回首字母小写的字符串
	 */
	public static String firstLetterLowercase(String str) {
		if (StringHelper.hasLength(str)) {
			StringBuffer wrod = new StringBuffer();
			str = wrod.append(str.substring(0, 1).toLowerCase()).append(str.substring(1)).toString();
		}
		return str;
	}

	/**
	 * 
	 * 通过正则表达式检查某个字符串是否满足某种格式
	 * 
	 * @param str
	 *            - 字符串，不能为空或null
	 * @param regex
	 *            - 正则表达式，不能为空或null
	 * @return boolean 满足正则表达式规定格式时返回true
	 * @throw IllegalArgumentException 当str或regex为空时抛出。
	 */
	public static boolean rightFormat(String str, String regex) {
		AssertUtils.notEmpty(str, "The str not should be empty or null!");
		AssertUtils.notEmpty(regex, "The regex not should be empty or null!");

		Pattern pattern = Pattern.compile(regex);
		return pattern.matcher(str).matches();
	}

	/**
	 * @see StringUtils#isBlank(String)
	 */
	public static boolean isBlank(String str) {
		return StringUtils.isBlank(str);
	}

	/**
	 * @see StringUtils#isNotBlank(String)
	 */
	public static boolean isNotBlank(String str) {
		return StringUtils.isNotBlank(str);
	}

	/**
	 * @see StringUtils#trimToEmpty(String)
	 */
	public static String trimToEmpty(String str) {
		return StringUtils.trimToEmpty(str);
	}

	/**
	 * 
	 * 根据分隔符拆分字符串，并以String数组返回。
	 * <p>
	 * 例如，字符串 <tt>字符串 "boo|and|foo"</tt>, 使用这些表达式可生成以下结果:
	 * 
	 * <blockquote>
	 * <table cellpadding=1 cellspacing=0 summary="Split examples showing regex and result">
	 * <tr>
	 * <th>Separator</th>
	 * <th>结果</th>
	 * </tr>
	 * <tr>
	 * <td align=center>|</td>
	 * <td><tt>{ "boo", "and", "foo" }</tt></td>
	 * </tr>
	 * </table>
	 * </blockquote>
	 * 
	 * @param str
	 *            - 被拆分的字符串，不能为Blank。
	 * @param separator
	 *            - 分隔符，不能为Null。
	 * @return String[] - 返回被拆分后的数字。
	 * @throws IllegalArgumentException
	 *             - if str is blank, separator is null.
	 * @see Separator
	 * @see String#split(String)
	 */
	public static String[] breakUp(String str, Separator separator) {
		AssertUtils.isTrue(isNotBlank(str), "The string not should be blank!");
		AssertUtils.notNull(separator, "The separator not should be null!");
		return str.split(separator.getRegex());
	}

	/**
	 * @see StringUtils#removeEndIgnoreCase(String, String)
	 * */
	public static String removeEndIgnoreCase(String str, String remove) {
		return StringUtils.removeEndIgnoreCase(str, remove);
	}

	/**
	 * @see StringUtils#removeEnd(String, String)
	 * */
	public static String removeEnd(String str, String remove) {
		return StringUtils.removeEnd(str, remove);
	}

	/**
	 * @see StringUtils#removeStart(String, String)
	 * */
	public static String removeStart(String str, String remove) {
		return StringUtils.removeStart(str, remove);
	}

	/**
	 * @see StringUtils#removeStartIgnoreCase(String, String)
	 * */
	public static String removeStartIgnoreCase(String str, String remove) {
		return StringUtils.removeStartIgnoreCase(str, remove);
	}

	/**
	 * @see StringUtils#remove(String, String)
	 * */
	public static String remove(String str, String remove) {
		return StringUtils.remove(str, remove);
	}

	/**
	 * @see StringUtils#endsWithIgnoreCase(String, String)
	 * */
	public static boolean equalsIgnoreCase(String str1, String str2) {
		return StringUtils.equalsIgnoreCase(str1, str2);
	}

	/**
	 * @see StringUtils#equals(String, String)
	 */
	public static boolean equals(String str1, String str2) {
		return StringUtils.equals(str1, str2);
	}

	/**
	 * @see StringUtils#indexOf(String, String)
	 * */
	public static int indexOf(String str, String searchStr) {
		return StringUtils.indexOf(str, searchStr);
	}

	/**
	 * 
	 * 将传入的字符串参数以给定的分隔符分隔合并为新的字符串。当传入的字符串参数为”Blank“，不会进行合并 例如：
	 * 
	 * <pre>
	 * StringHelper.merge(Separator.AND, {}) = ""
	 * StringHelper.merge(Separator.AND, null) = ""
	 * StringHelper.merge(Separator.AND, {"A", "B", "C"}) = A&B&C
	 * StringHelper.merge(Separator.AND, {null, "A", "B"})  = A&B
	 * StringHelper.merge(Separator.AND, { null, null, null }) = ""
	 * StringHelper.merge(Separator.AND, { "", "", "" }) = ""
	 * StringHelper.merge(Separator.AND, { "A", "  ", "C" }) = A&C
	 * StringHelper.merge(Separator.AND, { "   ", "  ", "  " }) = ""
	 * </pre>
	 * 
	 * @param separator
	 *            - 分隔符，不能为null。
	 * @param args
	 *            - 被合并的字符串参数数组。
	 * @return String - 返回被合并的字符串，不可能为null，可能为: ""
	 * @throws IllegalArgumentException
	 *             - 当separator为null时抛出。
	 */
	public static String merge(Separator separator, String... args) {
		AssertUtils.notNull(separator, "The separator not should be null!");

		StringBuffer str = new StringBuffer();
		if (ArrayHelper.isNotEmpty(args)) {
			int length = args.length;
			int cursor = length - 1;

			for (int index = 0; index < length; index++) {
				String arg = args[index];
				if (StringHelper.isNotBlank(arg)) {
					str = str.append(arg);
					if (index < cursor)
						str.append(separator.getCode());
				}
			}// end for
		}
		return removeEnd(str.toString(), separator.getCode());
	}

	/**
	 * @see StringUtils#defaultString(String)
	 * */
	public static String defaultString(String str) {
		return str == null ? EMPTY : str;
	}

	/**
	 * @see StringUtils#defaultString(String, String)
	 */
	public static String defaultString(String str, String defaultStr) {
		return str == null ? defaultStr : str;
	}

	/**
	 * @see StringUtils#defaultIfBlank(String, String)
	 */
	public static String defaultIfBlank(String str, String defaultStr) {
		return StringUtils.isBlank(str) ? defaultStr : str;
	}

	/**
	 * @see StringUtils#defaultIfEmpty(String, String)
	 */
	public static String defaultIfEmpty(String str, String defaultStr) {
		return StringUtils.isEmpty(str) ? defaultStr : str;
	}

	/**
	 * @see StringUtils#reverse(String)
	 */
	public static String reverse(String str) {
		if (str == null) {
			return null;
		}
		return new StrBuilder(str).reverse().toString();
	}
	
	/**
	 * 随机产生编码
	 * @param prefix 字符串前缀,可以为空
	 * @param numLen 数字的长度
	 * @return 字符串前缀+numLen位随机数字
	 */
	public static String randomCode(String prefix,int numLen) {
		if (numLen == 0) {
			return prefix;
		}
		StringBuffer sb = new StringBuffer(StringHelper.defaultIfBlank(prefix,""));
		Random rnd = new Random();  
	    for(int i=0; i < numLen; i++) {
	    	sb.append((char)('0' + rnd.nextInt(10)));
	    }
	    return sb.toString();  
	}
	
	
}
